# 练习案例

#  有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？
import functools
import json
import math
import time

from pip._vendor import requests
from selenium import webdriver


def learn_1():
    # 装所有的数据并且去重
    total_num = set()
    # 百位可以选1,2,3,4
    for i in range(1, 5):
        # 十位可以选1,2,3,4
        for j in range(1, 5):
            # 个位可以选1,2,3,4
            for k in range(1, 5):
                # 组成的数字 数字不能重复
                if not i == j == k and not i == j and not j == k and not i == k:
                    num = 10 ** 2 * i + 10 * j + k
                    total_num.add(num)
    return total_num


print(f"learn_1,count:{len(learn_1())},detail:{learn_1()}")


# 需求: 企业发放的奖金根据利润提成。从键盘输入当月利润I，求应发放奖金总数？
# 利润(i)低于或等于10万元时，奖金可提10%；
# 利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
# 20万到40万之间时，高于20万元的部分，可提成5%；
# 40万到60万之间时高于40万元的部分，可提成3%；
# 60万到100万之间时，高于60万元的部分，可提成1.5%
# 高于100万元时，超过100万元的部分按1%提成

def learn_2():
    # 输入值
    i = eval(input("请输入当月利润:"))
    if i <= 10:
        bonus = i * 0.1
    elif 10 < i <= 20:
        bonus = 10 * 0.1 + (i - 10) * 0.075
    elif 20 < i <= 40:
        bonus = 10 * (2 * 0.075 + 0.1) + (i - 20) * 0.05
    elif 40 < i <= 60:
        bonus = 10 * (2 * 0.075 + 0.1 + 2 * 0.05) + (i - 40) * 0.03
    elif 60 < i <= 100:
        bonus = 10 * (2 * 0.075 + 0.1 + 2 * 0.05 + 4 * 0.03) + (i - 60) * 0.015
    else:
        bonus = 10 * (2 * 0.075 + 0.1 + 2 * 0.05 + 4 * 0.03 + 4 * 0.015) + (i - 100) * 0.015
    return round(bonus, 4)


# print("learn_2:", learn_2())


# 需求:输入某年某月某日，判断这一天是这一年的第几天？
# 思路:以5月20日为例，应该先把前四个月的加起来，然后再加上20天即本年的第几天
# 特殊情况就是: 如果年份为闰年且输入月份大于2时需考虑多加一天

def copy_list_1(arr_list):
    if arr_list is None:
        raise Exception("输入集合为空")
    if len(arr_list) < 1:
        return []
    # 列表切片
    new_list = arr_list[:]
    return new_list


def copy_list_2(arr_list):
    if arr_list is None:
        raise Exception("输入集合为空")
    if len(arr_list) < 1:
        return []
    # copy
    new_list = arr_list.copy()
    return new_list


# print("copy_list_1:", copy_list_1([1, 2, True, False]))
# print("copy_list_2:", copy_list_2([1, 2, True, False]))


# 题目: 判断101-200之间有多少个素数，并输出所有素数。
# 分析:
# 1.数据变化的范围是从101-200 所以需要使用循环
# 2.素数: 只能被1和本身整除的数 所以需要一个变量从1变到本身
# 3.判断: 如果有一个非1和本身的数被整除 则跳出循环 判断下一个数字
# 如果循环完成，都只有1和本身能被整除 说明符合条件 计数器+1
def learn_3():
    return_list = []
    for index in range(101, 200):
        # print(index)
        for val in range(index, 0, -1):
            if index % val == 0 and val != 1 and index != val:
                break
        else:
            return_list.append(index)
            continue

    return return_list


# print("learn_3:", learn_3())
# print("learn_3 count:", len(learn_3()))


# 题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
# 例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方
# 程序分析:利用for循环控制100-999个数，每个数分解出个位，十位，百位
# 核心: 就是如何获取到每个位上的数字
# 例子: 12345


def learn_04():
    ret_list = []
    for val in range(100, 999):
        # 提取个位数
        n1 = val % 10
        # 提取十位数
        n2 = val // 10 % 10
        # 提取百位数
        n3 = val // 100 % 10
        if int(math.pow(n3, 3) + math.pow(n2, 3) + math.pow(n1, 3)) == val:
            ret_list.append(val)
    return ret_list


print("learn_04:", learn_04())


# 题目: 一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同
def learn_05(number):
    str_number = str(number)
    new_number = str_number[::-1]
    if str_number == new_number:
        return True
    else:
        return False


print("learn_05:", learn_05(23432))


# 题目:斐波那契数列
# # 程序分析: 斐波那契数列(Fibonacci sequence)，又称黄金分割数列，指的是这样一个数列:
# # 1 1 2 3 5 8 13 21 34 55....

def learn_06(n):
    fibs = [1, 1]
    if n == 1:
        return [1]
    if n == 2:
        return [1, 1]
    for index in range(2, n):
        # 前面两项和相加
        fibs.append(fibs[-1] + fibs[-2])
    return fibs


print("fibonacci2", learn_06(10))


# 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
def learn_07(param):
    ret_dict = {}
    for p in param:
        if str(p).isalpha():
            do_save(ret_dict, "字母")
        elif str(p).isalnum():
            do_save(ret_dict, "数字")
        elif str(p).isspace():
            do_save(ret_dict, "空格")
        else:
            do_save(ret_dict, "其他")
    return ret_dict


def do_save(ret_dict, key):
    a = ret_dict.get(key)
    if a:
        ret_dict[key] += 1
    else:
        ret_dict[key] = 1


# 求s=a+aa+aaa+aaaa+aa…a的值

def learn_08(target_num, count=2):
    target_str = str(target_num)
    if not target_str.isalnum():
        raise Exception("请输入数字!")
    if count < 0:
        raise Exception("次数不能小于零!")
    if count < 2:
        return int(target_num) + int(target_num * 2)
    target_list = []
    for val in range(1, count + 1):
        target_list.append(target_str * val)

    print("target_list:", target_list)

    # 利用lambda求和
    return functools.reduce(lambda x, y: int(x) + int(y), target_list)


# 题目:一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数

def learn_09(count):
    return_list = []
    for index in range(1, count + 1):
        num_list = []
        for val in range(1, index):
            # 所有可以被整除的数放入集合
            if index % val == 0:
                num_list.append(val)
        if sum(num_list) == index:
            print(str(index) + "=" + "+".join(map(str, num_list)))
            return_list.append(index)

    return return_list


print("learn_09:", learn_09(1000))


# 题目: 将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。
# 程序分析:对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成:
# (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
# (2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
# (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步
def dec_prime_factor(number):
    # 如果等于1直接结束
    if number == 1:
        return []
    for val in range(2, number + 1):
        # 返回的一个原组 (0)为商 (1)为余数
        rects = divmod(number, val)
        if rects[1] == 0:
            # 如果整除则合并列表
            return [val] + dec_prime_factor(rects[0])


print("dec_prime_factor:", dec_prime_factor(180))


# 题目: 一球从100米高度自由落下，每次落地后反跳回原高度的一半
# 再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

def learn_10(height, time):
    if not height:
        return 0
    for val in range(time):
        height = height / 2

    return height


# 题目: 猴子吃桃问题:猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，
# 又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。
# 到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

def learn_11(num, total):
    for val in range(num, 1, -1):
        total = (total + 1) * 2
    return total


# 题目: 求1+2!+3!+...+20!的和


def learn_12(num):
    return functools.reduce(lambda x, y: x * y, [x for x in range(num, 1, -1)])


# 获取拉勾网职位信息

def get_job():
    # 1.准备url和创建浏览器对象
    url = "https://www.lagou.com/jobs/list_java?gj=5-10%E5%B9%B4&px=default&yx=25k-50k&gx=%E5%85%A8%E8%81%8C&city=%E6%AD%A6%E6%B1%89#order"
    # 选择谷歌浏览器
    driver = webdriver.Chrome()
    # 2.发送请求
    driver.get(url)
    # 3.根据实际需求判断是否需要操作滚动条
    for index in range(3):
        driver.execute_script("window.scrollBy(0,1000);")
        time.sleep(3)
    # 4.解析数据
    process_data(driver)
    # 5.翻页 找到下一页的按钮即可
    page_info = driver.find_element_by_xpath("//div[@class='item_con_pager']")
    for index in range(0, 2):
        try:
            page_list = page_info.find_element_by_xpath("//div[@class='pager_container']").find_elements_by_xpath(
                "//span[@class='pager_not_current']")
            next_page = page_list[0]
            next_page.click()
            time.sleep(3)
            process_data(driver)
            # 再次进行解析数据
            print(f"================第{index + 1}页================")
        except Exception as e:
            print(e)
            process_data(driver)

    # 7.退出浏览器
    driver.quit()


# 解析数据
def process_data(driver):
    li_list = driver.find_elements_by_xpath("//ul[@class='item_con_list']//li")
    for li in li_list:
        # 职位以及地区
        position = li.find_element_by_xpath(".//h3").text
        address = li.find_element_by_xpath(".//em").text
        # 公司名称
        company_name = li.find_element_by_xpath(".//div[@class='company_name']/a").text
        # 薪资范围 经验及学历要求
        li_b_l = li.find_element_by_xpath(".//div[@class='p_bot']//div[@class='li_b_l']").text.strip()
        # 工作内容
        span_list = li.find_elements_by_xpath(".//div[@class='list_item_bot']//div[@class='li_b_l']")
        work = ""
        for k in span_list:
            work += k.text
        # 公司规模
        industry = li.find_element_by_xpath(".//div[@class='industry']").text
        # 公司介绍(福利 团队等等)
        introduce = li.find_element_by_xpath(".//div[@class='li_b_r']").text
        # 5.保存数据 这里为了演示将数据保存到字典中即可
        print({"公司名称": company_name, "职位": position, "地区": address, "薪资": li_b_l, "技能标签": work, "公司规模": industry,
               "公司介绍": introduce})


# 通过requests爬取接口信息
def get_job_1():
    url = "https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false"
    # pn 页数
    data = "first=false&pn=2&kd=java"
    url_start = "https://www.lagou.com/jobs/list_java?city=%E6%88%90%E9%83%BD&cl=false&fromSearch=true&labelWords=&suginput="

    headers = {
        "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
        "origin": "https://www.lagou.com",
        "referer": "https://www.lagou.com/jobs/list_java?labelWords=&fromSearch=true&suginput=",
        "sec-fetch-dest": "empty",
        "sec-fetch-mode": "cors",
        "sec-fetch-site": "same-origin",
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.193 Safari/537.36", }
    s = requests.Session()
    # 请求首页获取cookies
    s.get(url_start, headers=headers, timeout=3)
    # 为此次获取的cookies
    cookie = s.cookies
    response = s.post(url, data=data, headers=headers, cookies=cookie)
    response.encoding = response.apparent_encoding
    text = json.loads(response.text)
    info = text["content"]["positionResult"]["result"]
    for i in info:
        job_info = {}
        companyFullName = i["companyFullName"]
        companyShortName = i["companyShortName"]
        companyLogo = i["companyLogo"]
        companySize = i["companySize"]
        industryField = i["industryField"]
        financeStage = i["financeStage"]
        companyLabelList = i["companyLabelList"]
        positionLables = i["positionLables"]
        salary = i["salary"]
        salaryMonth = i["salaryMonth"]
        workYear = i["workYear"]
        jobNature = i["jobNature"]
        education = i["education"]
        positionAdvantage = i["positionAdvantage"]
        job_info.setdefault("companyFullName", companyFullName)
        job_info.setdefault("companyShortName", companyShortName)
        job_info.setdefault("companyLogo", companyLogo)
        job_info.setdefault("companySize", companySize)
        job_info.setdefault("industryField", industryField)
        job_info.setdefault("financeStage", financeStage)
        job_info.setdefault("companyLabelList", companyLabelList)
        job_info.setdefault("positionLables", positionLables)
        job_info.setdefault("salary", salary)
        job_info.setdefault("salaryMonth", salaryMonth)
        job_info.setdefault("workYear", workYear)
        job_info.setdefault("jobNature", jobNature)
        job_info.setdefault("education", education)
        job_info.setdefault("positionAdvantage", positionAdvantage)
        print(job_info)
    # print(response.text)


# 1.复制普通文本文件
def copy_txt(path):
    old_file = open(path, "r", encoding="utf8")

    new_file = open(path + ".bak", "w", encoding="utf8")

    while True:
        content = old_file.readline()
        if content:
            new_file.writelines(content)
        else:
            break

    # 关闭资源
    old_file.close()
    new_file.close()


# 2.复制图片
def copy_image(path):
    old_file = open(path, "rb")
    new_path = path[:path.rfind(".")] + "_副本" + path[path.rfind("."):]
    new_file = open(new_path, "wb")

    while True:
        content = old_file.readline()
        if content:
            new_file.write(content)
        else:
            break

    # 关闭资源
    old_file.close()
    new_file.close()


def get_school():
    url = "https://api.eol.cn/gkcx/api/?access_token=&admissions=&central=&department=" \
          "&dual_class=&f211=&f985=&is_dual_class=&is_recruitment=1&keyword=&page=1" \
          "&province_id=&request_type=1&school_type=&signsafe=&size=30" \
          "&sort=view_total&type=&uri=apidata/api/gk/school/lists"

    payload = {}
    headers = {"content-type": "application/x-www-form-urlencoded; charset=UTF-8",
               "sec-fetch-dest": "empty",
               "sec-fetch-mode": "cors",
               "sec-fetch-site": "same-origin",
               "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.193 Safari/537.36", }

    response = requests.request("GET", url, headers=headers, data=payload)
    response.encoding = response.apparent_encoding
    text = json.loads(response.text)
    info_list = text["data"]["item"]
    for info in info_list:
        school = {}
        school.setdefault("学校名称", info['name'])
        school.setdefault("学校类型", info['dual_class_name'])
        school.setdefault("学校地区", info['city_name'] + info['county_name'])
        school.setdefault("学校地址", info['address'])
        school.setdefault("学校等级", info['level_name'])
        school.setdefault("学校性质", info['nature_name'])
        school.setdefault("学校类型", info['type_name'])
        school.setdefault("学校招生地址", info['answerurl'])
        print(school)


# get_school()
# print(str("\u77f3\u6cb3\u5b50\u5927\u5b66"))
# print("copy_image:", copy_image("莫山山.jpg"))
# get_job()
# get_job_1()
# print("learn_12:", learn_12(7))
# print("learn_11:", learn_11(10, 1))
# print("learn_10:", learn_10(100, 10))
# print("learn_08:", learn_08("2", 4))
# print("learn_07:", learn_07("sdhisdsdgs 12423523 ,,,qwedq #&&^^#!3212441"))
# # 对象定义
# class Student:
#
#     def __init__(self, studentId, name):
#         self.id = studentId
#         self.name = name
#
#     def __repr__(self):
#         return 'id = ' + str(self.id) + ', name = ' + self.name
#
#
# stu = Student(1, "学学")
# print("stu.id:", stu.id)
# print("stu.name:", stu.name)
# print(stu.__repr__())
